The most common way to fill a graphics path with figures is to use its plotter commands. The usage of plotter commands follows these steps:

1. A new figure must first be started by calling the StartFigure method and passing the first point of the figure.
2. Once you have started a figure you can call the Plotter Drawing Commands that all draw a segment from the last point in the path to a new location specified in the command. The plotter commands all have a To or Tos suffix - for example: LineTo, LineTos (performs multiple LineTo), CubicBezierTo, CircularArcTo and EllipticalArcTo.
3. When you are finished filling the current figure you can call CloseFigure() to close it or do nothing if you intend the figure to remain open.

The following example renders a line and a triangle inside a graphics path:

NGraphicsPath path = new NGraphicsPath();
// draw a simple line (open figure)
path.StartFigure(10, 10);
path.LineTo(100, 100);
// add a triangle (closed figure)
path.StartFigure(10, 10);
path.LineTo(100, 10);
path.LineTo(10, 100);
path.CloseFigure();

The NGraphicsPath provides a wealth of methods that help you add geometry objects to the path, such as rectangles, ellipses, triangles etc. These methods can be called at any stage of the graphics path construction. Based on type of figure being added to the graphics path, the methods are divided as follows:

• Closed Figures - AddTriangle, AddRectangle, AddQuad, AddCircle, AddEllipse, AddPolygon, AddPie, AddRoundedRectangle.
  Common for these methods is that they add an entire closed figure inside the graphics path. After adding a closed figure to the path you cannot use the Plotter Drawing Commands (LineTo, CubicBezierTo etc.), because the path does not have a started open figure. You need to first start a figure with the StartFigure command or call some of the methods that add open figures, prior to using the Plotter Drawing Commands again.
  
• Open Figures - AddLineSegment, AddCircleSegment, AddEllipseSegment, AddCubicBezier, AddPolyline, AddNurbsCurve.
  Common for these methods is that emit a LineTo command to connect the last path point with the primitive start point, if the current figure is not closed.
  If the current figure is closed, these methods first emit a StartFigure with the start point of the open figure being added.

The following code sample adds a rectangle and two line segments to a path:

// AddRectangle adds an entiry closed figure
path.AddRectangle(new NRectangle(0, 0, 100, 100));
// AddLineSegment sees that the current figure is closed and starts a new one (20, 20).
path.AddLineSegment(new NLineSegment(20, 20, 40, 30));
// AddLineSegment sees that the current figure is open and emits a new line to connect with it
path.AddLineSegment(new NLineSegment(30, 100, 25, 35));
// At this point the path has one closed rectangle figure, and open open figure that has the following points:
// (START:(20,20),LINETO(40,30),LINETO(30,100),LINETO(25,35)

You can get the count of figures contained inside a graphics via the GetFiguresCount() method. You can get information about the figure at a specific index via the GetFigure method. The following code sample iterates the figures of a path:

int count = path.GetFigureCount();
for (int i = 0; i < count; i++)
{
 NGraphicsPathFigure figure = path.GetFigure(i);
 
 // determine whether figure is closed.
 bool isClosed = figure.Closed;
 // get figure bounds
 NRectangle figureBounds = path.GetFigureBounds(figure);
 // get figure path
 NGraphicsPath figurePath = path.GetFigurePath(figure);
}

A graphics path is said to be flat, if it contains only line segments (i.e. does not contain cubic bezier segments). You can query whether a path is flat via the IsFlat property. The conversion of a non-flat graphics path to a flat one is called flattening and results in a graphics path, in which bezier curves from the original path are approximated with line segments. You can flatten a graphics path via the Flatten method.

You can query whether a point hits the filled area of the path via the Contains method. You can query whether a point hits the stroked outline of a path via the ContainsOnOutline method.